Java 线程

字数

2605 字

阅读时间

12 分钟

学习资料

黑马官方资料：G:\开发\黑马JUC\并发编程笔记
古春波：java并发编程/java并发1.md · 古春波/java-construct - Gitee.com
阿里员工：F:\repo\JavaNote

创建和运行线程

方法一 Thread

java

// 构造方法的参数是给线程指定名字，，推荐给线程起个名字
Thread t1 = new Thread("t1") {
	@Override
	// run 方法内实现了要执行的任务
	public void run() {
		log.debug("hello");
	}
};
t1.start();

方法二 Runnable

把【线程】和【任务】（要执行的代码）分开：

Thread 代表线程
Runnable 可运行的任务（线程要执行的代码）

java

// 创建任务对象
Runnable task2 = new Runnable() {
	@Override
	public void run() {
		log.debug("hello");
	}
};
// 参数1 是任务对象; 参数2 是线程名字，推荐给线程起个名字
Thread t2 = new Thread(task2, "t2");
t2.start();

java8 之后可以用 lambda：

java

// 创建任务对象 
Runnable task2 = () -> log.debug("hello"); 
// 参数1 是任务对象; 参数2 是线程名字，推荐 
Thread t2 = new Thread(task2, "t2"); 
t2.start();

Thread 和 Runnbale 的关系（源码）

方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
用 Runnable 更容易与线程池等高级 API 配合
用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

推荐用 Runnable

方法三 FutrueTask

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况：

java

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 实现多线程的第三种方法可以返回数据
        FutureTask task = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("running...");
                Thread.sleep(3000);
                return 100;
            }
        });
        
        // 主线程阻塞，同步等待 task 执行完毕的结果
        Thread t1 = new Thread(task, "t1");
        t1.start();
        
        log.debug("{}",task.get());
    }

查看进程线程

Windows

任务管理器：可以查看进程和线程数，也可以用来杀死进程
tasklist：查看进程
taskkill：杀死进程

Linux

ps -fe：查看所有进程
ps -fT -p <PID>：查看某个进程（PID）的所有线程
kill：杀死进程
top：按大写 H 切换是否显示线程
top -H -p <PID>：查看某个进程（PID）的所有线程

Java

jps：命令查看所有 Java 进程
jstack：查看某个 Java 进程（PID）的所有线程状态
jconsole：来查看某个 Java 进程中线程的运行情况（图形界面）

jconsole 远程监控配置

#TODO

线程运行的原理

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存：

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码：

线程的 cpu 时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

常见方法

start 与 run

直接调用 run() 是在主线程中执行了 run()，没有启动新的线程
使用 start() 是启动新的线程，通过新的线程间接执行 run()方法中的代码

sleep 与 yield

sleep

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
睡眠结束后的线程未必会立刻得到执行
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

线程优先级

线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

案例：防止 CPU 占用 100%

在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权给其他程序

java

while (true) {
	try {
		Thread.sleep(50);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

可以用 wait 或条件变量达到类似的效果
不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
sleep 适用于无需锁同步的场景

join

等待线程运行结束

java

public class Test10 {  
    static int r = 0;  
    public static void main(String[] args) throws InterruptedException {  
        test1();  
    }  
    private static void test1() throws InterruptedException {  
        log.debug("开始");  
        Thread t1 = new Thread(() -> {  
            log.debug("开始");  
            sleep(1);  
            log.debug("结束");  
            r = 10;  
        },"t1");  
        t1.start();  
        t1.join();  
        log.debug("结果为:{}", r);  
        log.debug("结束");  
    }  
}

在主线程中调用t1.join，则主线程会等待t1线程执行完之后再继续执行 Test10.java

interrupt

`interrupt()` 的本质

调用某个线程的 interrupt() 方法，其实就是给这个线程打一个“中断标记”（一个布尔 flag），并不会直接杀掉线程。

可以理解成：
👉 线程自己身上贴了一个“有人要让我停”的小纸条
👉 至于它停不停、什么时候停，要看线程内部的代码怎么写。

被打断的几种情况

情况1：线程在等待/阻塞（sleep, wait, join）

java

try {
    Thread.sleep(10000);
} catch (InterruptedException e) {
    System.out.println("被打断了");
}

如果线程正处于阻塞状态，interrupt() 会让它抛出 InterruptedException。
抛出异常的同时，中断标记会被清空（变成 false）。
线程此时能不能停下来，取决于你怎么处理异常：
- 如果你在 catch 里直接 return，线程就结束了。
- 如果你 catch 之后什么都不做，线程就会继续跑。

情况2：线程在正常运行

java

while(true) {
    int i = 0;
    i++;
}

如果线程一直在运行普通代码，不会因为 interrupt() 而停下。
除非你在循环里主动检查 Thread.currentThread().isInterrupted()，然后决定 break。 👉 所以，这类代码不会停，要配合自己写的中断检查逻辑。

情况2：打断 park

LockSupport.park() 的作用：

park() 会让当前线程进入 WAITING 状态，直到被唤醒。
唤醒方式有两种：
1. 其他线程调用 unpark(thread)
2. 当前线程被 interrupt()

如果线程在 park() 时被打断，会发生两件事：

park() 立即返回，线程不再阻塞。
线程的中断标记会被保留（不会被清空！）
- 这一点和 sleep()、wait() 不同。
- sleep() 和 wait() 会抛出 InterruptedException 并清空标记。
- 但 park() 不会抛异常，只是返回，同时保留标记。

两阶段终止模式

java

public class Test {  
    public static void main(String[] args) throws InterruptedException {  
        TwoPhaseTermination tpt = new TwoPhaseTermination(); 
         
        tpt.start();  
        
        Thread.sleep(3500);
        tpt.stop();
    }  
}
  
class TwoPhaseTermination {  
	
    private Thread monitor;  
    
	//启动监控线程
    public void start() {  
        monitor = new Thread(() -> {  
            while (true) {  
                Thread current = Thread.currentThread();  
                if (current.isInterrupted()) {  
                    log.debug("料理后事");  
                    break;  
                }  
                try {  
                    Thread.sleep(1000);  //情况1-打断
                    log.debug("执行监控记录");  //情况2-打断
                } catch (InterruptedException e) {  
	                e.printStackTrace();
	                //重新设置打断标记
	                current.interrupted();
                }  
            }  
        });  
        
        monitor.start();  
    }  
    
    // 停止监控线程  
    public void stop() {  
        monitorThread.interrupt();  
    }  
}

不推荐的方法

主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

java

public class Test15 {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(() -> {  
            while (true) {  
                if (Thread.currentThread().isInterrupted()) {  
                    break;  
                }  
            }  
            log.debug("结束");  
        }, "t1");  
        t1.setDaemon(true);  
        t1.start();  
  
        Thread.sleep(1000);  
        log.debug("结束");  
    }  
}

垃圾回收器线程就是一种守护线程
Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

五种状态

这是从 操作系统 层面来描述的

六种状态

这是从 Java API 层面来描述的根据 Thread.State 枚举，分为六种状态

java

public class TestState {  
    public static void main(String[] args) throws IOException {  
        Thread t1 = new Thread("t1") {  
            @Override  
            public void run() {  
                log.debug("running...");  // new
            }  
        };  
  
        Thread t2 = new Thread("t2") {  
            @Override  
            public void run() {  
                while(true) { // runnable  
  
                }  
            }  
        };  
        t2.start();  
  
        Thread t3 = new Thread("t3") {  
            @Override  
            public void run() {  
                log.debug("running...");  // terminated
            }  
        };  
        t3.start();  
  
        Thread t4 = new Thread("t4") {  
            @Override  
            public void run() {  
                synchronized (TestState.class) {  
                    try {  
                        Thread.sleep(1000000); // timed_waiting 有时限的等待  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        };  
        t4.start();  
  
        Thread t5 = new Thread("t5") {  
            @Override  
            public void run() {  
                try {  
                    t2.join(); // waiting 没有时限  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        };  
        t5.start();  
  
        Thread t6 = new Thread("t6") {  
            @Override  
            public void run() {  
                synchronized (TestState.class) { // blocked 锁  
                    try {  
                        Thread.sleep(1000000);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        };  
        t6.start();  
  
        try {  
            Thread.sleep(500);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        
        log.debug("t1 state {}", t1.getState());  
        log.debug("t2 state {}", t2.getState());  
        log.debug("t3 state {}", t3.getState());  
        log.debug("t4 state {}", t4.getState());  
        log.debug("t5 state {}", t5.getState());  
        log.debug("t6 state {}", t6.getState());  
        System.in.read();  
    }  
}

贡献者

Lilyana

页面历史

最后编辑于大约 1 小时前

查看完整历史

Java 线程 ​

创建和运行线程 ​

方法一 Thread ​

方法二 Runnable ​

方法三 FutrueTask ​

查看进程线程 ​

Windows ​

Linux ​

Java ​

jconsole 远程监控配置 ​

线程运行的原理 ​

栈与栈帧 ​

线程上下文切换 ​

常见方法 ​

start 与 run ​

sleep 与 yield ​

join ​

interrupt ​

interrupt() 的本质 ​

被打断的几种情况 ​

两阶段终止模式 ​

不推荐的方法 ​

主线程与守护线程 ​

五种状态 ​

六种状态 ​

贡献者

页面历史

Java 线程

创建和运行线程

方法一 Thread

方法二 Runnable

方法三 FutrueTask

查看进程线程

Windows

Linux

Java

jconsole 远程监控配置

线程运行的原理

栈与栈帧

线程上下文切换

常见方法

start 与 run

sleep 与 yield

join

interrupt

`interrupt()` 的本质

被打断的几种情况

两阶段终止模式

不推荐的方法

主线程与守护线程

五种状态

六种状态